const cloud = require('wx-server-sdk');

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV // 使用当前环境
});

const db = cloud.database();

// 生成用户 ID
function generateUserId() {
  const now = new Date();
  const dateString = now.toISOString().replace(/[^0-9]/g, '').slice(0, 14); // YYYYMMDDHHmmSS
  const randomNum = Math.floor(Math.random() * 1000000).toString().padStart(6, '0'); // 生成六位随机数字
  return "U" + dateString + randomNum; // 拼接结果
}

// 构建用户 DTO 对象
function buildUserDtoFromUserPo(user) {
  const userDto = {
    userId: user.out_user_id,
    address: user.ext_info.address
      .sort((a, b) => b.is_default - a.is_default) // 排序，将 isDefault 为 true 的排在前面
      .map(address => ({
        addressId: address.address_id,
        contactName: address.contact_name,
        contactPhone: address.contact_phone,
        addressDesc: address.address_desc,
        addressCode: address.address_code,
        addressDetail: address.address_detail,
        isDefault: address.is_default
      })),
    roleType: user.role_type,
    phone: user.phone,
    merchantPermission: user.merchant_permission,
    nickName: user.nick_name || '微信用户', // 添加昵称字段
    snackAdminPermission: user.snack_admin_permission
  };
  return userDto;
}

// 保存用户手机号
async function savePhoneNumber(userId, encryptedData, iv, cloudID) {
  try {
    const userRecord = await db.collection('user').where({
      out_user_id: userId
    }).get();
    
    if (userRecord.data.length === 0) {
      console.error("用户不存在", userId);
      return {
        code: 404,
        message: '用户不存在',
        data: null
      };
    }
    
    const user = userRecord.data[0];
    const phoneRes = await cloud.getOpenData({
      list: [cloudID], // 微信开放数据
    });
    
    if (phoneRes?.list[0]?.data?.phoneNumber) {
      const phoneNumber = phoneRes?.list[0]?.data?.phoneNumber;
      user.phone = phoneNumber;
      
      // 更新用户手机号
      const updateRes = await db.collection('user').doc(user._id).update({
        data: {
          phone: phoneNumber,
          updated_at: db.serverDate() // 添加更新时间
        }
      });
      
      if (updateRes.stats.updated === 0) {
        console.error("更新用户手机号失败：", updateRes);
        return {
          code: 500,
          message: '更新用户信息失败',
          data: null
        };
      }
      
      return {
        code: 200,
        message: 'success',
        data: buildUserDtoFromUserPo(user)
      };
    } else {
      console.error("解密手机号失败：");
      return {
        code: 500,
        message: '解密手机号失败',
        data: null
      };
    }
  } catch (error) {
    console.error('保存手机号失败:', error);
    return {
      code: 500,
      message: 'Internal server error',
      data: null
    };
  }
}

// 获取用户信息
async function getUserInfo(request) {
  const { userId, encryptedData, iv, cloudID } = request;
  const wxContext = cloud.getWXContext();
  const openId = userId || wxContext.OPENID;

  try {
    // 如果传入了加密信息，则保存手机号
    if (encryptedData && iv && cloudID) {
      return await savePhoneNumber(openId, encryptedData, iv, cloudID);
    }

    // 查询用户信息
    const userRecord = await db.collection('user').where({
      out_user_id: openId
    }).get();

    // 如果用户不存在，创建一个新用户
    if (userRecord.data.length === 0) {
      const newUser = {
        user_id: generateUserId(), // 生成一个唯一的 user_id
        out_user_id: openId,
        role_type: ['user'],
        ext_info: {
          address: [],
        },
        create_ts: new Date()
      };

      await db.collection('user').add({
        data: newUser
      });

      return {
        code: 200,
        message: 'success',
        data: {
          userId: newUser.out_user_id,
          roleType: newUser.role_type,
          address: newUser.ext_info.address,
        }
      };
    }

    const user = userRecord.data[0];
    return {
      code: 200,
      message: 'success',
      data: buildUserDtoFromUserPo(user)
    };
  } catch (error) {
    console.error('获取用户信息失败:', error);
    return {
      code: 500,
      message: 'Internal server error',
      data: null
    };
  }
}

/**
 * 通用更新用户信息方法
 * @param {Object} request - 请求参数
 * @param {string} request.userId - 用户ID (openId)
 * @param {Object} request.updateFields - 要更新的字段对象
 * @returns {Promise<Object>} 返回更新结果
 */
async function updateUserInfo(request) {
  const { userId, updateFields } = request;

  // 验证参数
  if (!userId) {
    return {
      code: 400,
      message: '用户ID不能为空',
      data: null
    };
  }

  if (!updateFields || typeof updateFields !== 'object' || Object.keys(updateFields).length === 0) {
    return {
      code: 400,
      message: '更新字段不能为空',
      data: null
    };
  }

  try {
    // 查询用户是否存在
    const userRecord = await db.collection('user').where({
      out_user_id: userId
    }).get();

    if (userRecord.data.length === 0) {
      return {
        code: 404,
        message: '用户不存在',
        data: null
      };
    }

    // 构建更新数据，添加更新时间
    const updateData = {
      ...updateFields,
      update_ts: new Date()
    };

    // 更新用户信息
    const result = await db.collection('user').where({
      out_user_id: userId
    }).update({
      data: updateData
    });

    if (result.stats.updated === 0) {
      return {
        code: 500,
        message: '更新失败',
        data: null
      };
    }

    console.log('用户信息更新成功:', { userId, updateFields });

    return {
      code: 200,
      message: '用户信息更新成功',
      data: {
        userId: userId,
        updateFields: updateFields
      }
    };

  } catch (error) {
    console.error('更新用户信息失败:', error);
    return {
      code: 500,
      message: '更新用户信息失败',
      data: null
    };
  }
}


module.exports = {
  getUserInfo,
  updateUserInfo
};
